#!/bin/bash
ERR_FECHA=502

##############
# contadores #
##############
REG_VALIDOS=0
REG_INVALIDOS=0

REG_VALIDOS_TOT=0
REG_INVALIDOS_TOT=0

REG_LEIDOS=0

############################################################################################
## Chequeo que las variables esten configuradas y asi evitar ejecutar IniciarU nuevamente ##
############################################################################################
#Variables utilizas para validar el seteo de las mismas.
otrasvarComprobacion=($PATH $CONFDIR $CONFARCH)
carpetasComprobacion=($GRUPO $ARRIDIR $RECHDIR $BINDIR $MAEDIR $REPODIR $LOGDIR)
archmaeComprobacion=($prodmae $sucumae $climae)
archcomComprobacion=($detectarU $grabarParqueU $listarU $moverU $loguearU $iniciarU)

function seEjecutoIniciarU() {
  seEjecutoIniciar=0
  if [ ! ${#carpetasComprobacion[@]} -eq 0 ]; then
    ./LoguearU.sh -i "carpetasComprobacion tiene ${#carpetasComprobacion[@]} elementos" -c IniciarU
    seEjecutoIniciar=$(($seEjecutoIniciar+1))
  fi
  if [ ! ${#archmaeComprobacion[@]} -eq 0 ]; then
    ./LoguearU.sh -i "archmaeComprobacion tiene ${#archmaeComprobacion[@]} elementos" -c IniciarU
    seEjecutoIniciar=$(($seEjecutoIniciar+1))
  fi
  if [ ! ${#archcomComprobacion[@]} -eq 0 ]; then
    ./LoguearU.sh -i "archcomComprobacion tiene ${#archcomComprobacion[@]} elementos" -c IniciarU
    seEjecutoIniciar=$(($seEjecutoIniciar+1))
  fi
  if [ ! ${#otrasvarComprobacion[@]} -eq 0 ]; then
    ./LoguearU.sh -i "otrasvarComprobacion tiene ${#otrasvarComprobacion[@]} elementos" -c IniciarU
    seEjecutoIniciar=$(($seEjecutoIniciar+1))
  fi
  if [ $seEjecutoIniciar -eq 4 ]; then
    echo "1"
  else
    echo "0"
  fi
}

#Función que verifica si un archivo de instalaciones recibidas ya fue procesado
function verificarProcesados(){
  existe=`ls -1 $PROCESADAS | grep $arch`  #Busco con grep listando los archivos procesados
}

# Funcion que ordena el archivo de entrada
function ordenarArchivo(){
  sed 's|^\([^,]*,\)\([0-9]*\)/\([0-9]*\)/\([0-9]*\)\(,.*\)$|\1\4/\3/\2\5|' $1 > preorden.tmp
  sort -t',' -k 1n,3n -k 5,5r preorden.tmp -o posorden.tmp
  sed 's|^\([^,]*,\)\([0-9]*\)/\([0-9]*\)/\([0-9]*\)\(,.*\)$|\1\4/\3/\2\5|' posorden.tmp > $2
  rm preorden.tmp
  rm posorden.tmp
}

# Funcion que verifica si una fecha tiene formato AAAAMMDD valido
function verificarFormatoFecha(){
#set -x
	local error=false;
	dia=`echo "$1" | sed 's|^\([0-9]*\)/\([0-9]*\)/\([0-9]*\)|\1|'`
	mes=`echo "$1" | sed 's|^\([0-9]*\)/\([0-9]*\)/\([0-9]*\)|\2|'`
	anio=`echo "$1" | sed 's|^\([0-9]*\)/\([0-9]*\)/\([0-9]*\)|\3|'`
	if [ $mes -ge 13 ]; then
		error=true
	else
		case $mes in
		02|2)
		    resto4=`expr $anio % 4`
		    resto100=`expr $anio % 100`
		    resto400=`expr $anio % 400`
		    esbisiesto=false
		    if [ $resto4 -eq 0 ]; then
			if [ $resto100 -eq 0 ]; then
				if [ $resto400 -eq 0 ]; then
					esbisiesto=true
				fi
			else
				esbisiesto=true
			fi
			if [ $esbisiesto = true ]; then
				if [ $dia -gt 29 ]; then
					error=true
				fi
			else
				if [ $dia -gt 28 ]; then
					error=true
				fi
			fi
		    fi
		;;
		01|1|03|3|05|5|07|7|08|8|10|12)
			if [ $dia -gt 31 ]; then
				error=true
			fi
		;;
		04|4|06|6|09|9|11)
			if [ $dia -gt 30 ]; then
				error=true
			fi
		;;
		esac
	fi
	if [ $error = true ]; then
		echo $ERR_FECHA
	else
		echo 0
	fi
}

# Funcion que graba el registro de parque instalado
function grabarEnParqueInstalado(){

	let REG_VALIDOS+=2 #`expr $REG_VALIDOS + 2`
	let REG_VALIDOS_TOT+=2

	#Armamos la terna del bloque validado
	id_plan_comercial_tmp=`echo "$TMP_LINE" | cut -d"," -f3`
	id_clase_servicio_tmp=`echo "$TMP_LINE" | cut -d"," -f4`
	id_item_producto_tmp=`echo "$TMP_LINE" | cut -d"," -f6`
		
	#buscamos el ITEM_NAME del registro cabacera y detalle.
	ITEM_NAME_CAB=`grep "^.*,.*,$id_plan_comercial,.*,$id_clase_servicio,.*,.*,$id_item_producto,*" $prodmae | cut -d"," -f9 | sed 's-\r- -g'`
	ITEM_NAME_DET=`grep "^.*,.*,$id_plan_comercial_tmp,.*,$id_clase_servicio_tmp,.*,.*,$id_item_producto_tmp,*" $prodmae |cut -d"," -f9 | sed 's-\r- -g'`
	id_sucursal=`echo $archivo_ordenado | cut -d"-" -f2 | cut -d"." -f1`
	
	
	#buscamos el PRODUCT_TYPE_NAME del registro
	product_type_name=`grep "^.*,.*,$id_plan_comercial,.*,$id_clase_servicio,.*,.*,$id_item_producto,*" $prodmae | cut -d"," -f2`		
		
	reg_parque_instalado="$id_sucursal,$id_cliente,$ITEM_NAME_CAB,$ITEM_NAME_DET"				
	echo "$reg_parque_instalado" >> "$INSTALADO/$product_type_name"
		
}

# Función que graba el registro rechazado en el archivo de rechazados
function rechazarRegistro(){
 #$1 es el codigo de error por el cual no fue valido
 #$2 nombre del archivo procesado
 #$3 es el registro de input (detalle o cabecera)
 REG_INVALIDOS=`expr $REG_INVALIDOS + 1`
 REG_INVALIDOS_TOT=`expr $REG_INVALIDOS_TOT + 1`
 #Toma el hora y fecha en la que se rechazo el bloque
 DATE=`date`
 REG_RECHAZADOS="$DATE-$1-$3"
 
 #grabamos en el registro rechazado con el nombre del archivo procesado.
 echo "$REG_RECHAZADOS" >> "$RECHAZADAS/$2"
}

# Función que graba el bloque rechazado en el archivo de rechazados
function rechazarBloque(){

  REG_INVALIDOS=`expr $REG_INVALIDOS + 2`
  REG_INVALIDOS_TOT=`expr $REG_INVALIDOS_TOT + 2`

 #$1 es el codigo de error por el cual no fue valido
 #$2 nombre del archivo procesado
 #$3 y $4 es el registro de input cabecera y detalle
 
 #Toma el hora y fecha en la que se rechazo el bloque
 DATE=`date`
 REG_RECHAZADOS_CAB="$DATE-$1-$3"
 REG_RECHAZADOS_DET="$DATE-$1-$4"
 
 #grabamos en el registro rechazado con el nombre del archivo procesado.
 echo "$REG_RECHAZADOS_CAB" >> "$RECHAZADAS/$2"
 echo "$REG_RECHAZADOS_DET" >> "$RECHAZADAS/$2"
}

###################################################
# COMIENZO DEL SCRIPT
###################################################

#Verifico que ya se haya ejecutado IniciarU en esta misma sesión de usuario.
#Si todas las variables estan seteadas devuelve 1 "seEjecutoIniciarU".
resultado=`seEjecutoIniciarU`
if [ $resultado != 1 ]; then
  #El ambiente no está inicializado
  ./LoguearU.sh -i "El ambiente no está inicializado"  
  echo "El ambiente no esta inicializado. No se continua con la ejecucion"
  exit 901
fi

#Verifico si otro comando GrabarParqueU no se está ejecutando en este momento
proc_anter=`pgrep -n GrabarParqueU`
proc_actual=`pgrep -o GrabarParqueU`
if [ $proc_anter != $proc_actual ]; then
  $loguearU -e 500
  exit 500
fi

#Archivos a procesar
GRUPO=`pwd`
GRUPO=${GRUPO%/*}
RECIBIDAS=$GRUPO/inst_recibidas
ORDENADAS=$GRUPO/inst_ordenadas
PROCESADAS=$GRUPO/inst_procesadas
INSTALADO=$GRUPO/parque_instalado
RECHAZADAS=$GRUPO/inst_rechazadas
ARCHREC=`ls -A -B $RECIBIDAS`

#Grabo inicialización del comando en el Log : (2)
tot_arch=`ls -A1 -B $RECIBIDAS | wc -l`
$loguearU -i 51 -v $tot_arch
cant_rech=0
cant_ordenados=0

ARCHIVOS=`ls -m -B $RECIBIDAS | sed 's-,--g'`

ARCHIVOS_ORD=""

#Proceso los archivos de instalaciones recibidas
#for arch in "`ls -A1 -B $RECIBIDAS`"
for arch in ${ARCHIVOS[*]}
do
  if [ -f "$RECIBIDAS/$arch" ]; then
    $loguearU -i 52 -v $arch
    verificarProcesados $arch
    if [ $? = 0 ]; then
	$moverU $RECIBIDAS/$arch $RECHDIR
	$loguearU -e 501 -v $arch
	cant_rech=`expr $cant_rech + 1`
    else
	ordenarArchivo $RECIBIDAS/$arch $ORDENADAS/$arch
	ARCHIVOS_ORD=$ARCHIVOS_ORD" "$arch
	cant_ordenados=`expr $cant_ordenados + 1`
	$moverU $RECIBIDAS/$arch $PROCESADAS
    fi
  fi
done

#Decalaramos las Expresiones Regulares que vamos a ulitilizar para validar los archivos
REGEXP_REGISTRO="^[0-9]*,[0-9]\{1,2\}/[0-9]\{1,2\}/[0-9]\{4\},[0-9]*,[0-9]*,[Y,N],[0-9]*"

#Declaracion de variables que vamos a ultilizar para la validacion de bloque y campos de registro.
NRO_REG=0
ERROR_CAMPO=0
ERROR=" "
TMP_LINE=" "
CONTAR_RECH=0
CANT_REG_OK=0
GRABAR_PARQUE=false


#########
# DEBUG #
#########
echo "=================================================================="

echo "Cantidad recibidos "$tot_arch
$loguearU -i "Cantidad recibidos "$tot_arch
echo "Cantidad ordenados "$cant_ordenados
$loguearU -i "Cantidad ordenados "$cant_ordenados
echo "Cantidad rechazados "$cant_rech
$loguearU -i "Cantidad rechazados "$cant_rech
echo "=================================================================="

contador=0

#Recorremos los archivos de inst_procesadas para validar sus registros.
for archivo_ordenado in ${ARCHIVOS_ORD[*]}
do
    REG_INVALIDOS=0
    REG_VALIDOS=0
    if [ -f "$ORDENADAS/$archivo_ordenado" ]; then

	echo "PROCESANDO ARCHIVO :"$archivo_ordenado

	#Validamos los registros del archivo
	while read LINE
	do
		LINE=`echo "$LINE" | sed 's-\r--g'`
		#contador=$(($contador + 1))

		#verificamos si es un registro detalle o cabecera
		clase_servicio=`echo "$LINE" | cut -s -d, -f5 `
		
		if [ "$ERROR_CAMPO" = "0" ];then
			if [ "$clase_servicio" = "Y" ]; then
				#Validamos si es el primer registro de un bloque
				if [ $NRO_REG -eq 0 ]; then
					TMP_LINE="$LINE"
					NRO_REG=1
					CANT_REG_OK=1
				else
					#Encontramos dos registros cabecera seguidos
					#Grabamos en inst_rechazadas los bloques incompletos
					ERROR="Se encontraron dos registros cabecera seguidos"
					rechazarRegistro "$ERROR" "$archivo_ordenado" "$TMP_LINE"
					TMP_LINE="$LINE"
					NRO_REG=1
					CANT_REG_OK=1
				fi
			
			else
				#Si cumple que es una N y NRO_REG no es 0 entonces tengo un bloque
				if [ $NRO_REG -eq 0 ]; then
					#Encontramos un registro N sin cabecera Y
					ERROR="Se encontro un registro detalle sin cabecera"
					rechazarRegistro "$ERROR" "$archivo_ordenado" "$LINE"
					CANT_REG_OK=0
				else
					#Encontre un bloque: cambio al estado OK.
					CANT_REG_OK=2
				fi
			
			fi
		else
		    if [ "$ERROR_CAMPO" = "Y" ]  &&  [ "$clase_servicio" = "N" ]; then 
                          #Leo un registro N, luego de una Y invalida, rechazo el bloque
			  #               motivo    nombre archivo	cabecera    detalle	  
			  rechazarBloque "$ERROR" "$archivo_ordenado" "$TMP_LINE" "$LINE" 
			  ERROR_CAMPO="0"
 			  NRO_REG=0
			  CANT_REG_OK=0
		    else
			if [ "$ERROR_CAMPO" = "Y" ] && [ "$clase_servicio" = "Y" ]; then 
			      #rechazo el Y invalido, y voy a validar el nuevo registro Y que acabo de leer
			      rechazarRegistro "$ERROR" "$archivo_ordenado" "$TMP_LINE"
			      TMP_LINE="$LINE"
			      NRO_REG=1
			      CANT_REG_OK=1
			      ERROR_CAMPO="0"
			fi
		    fi
		fi

		#Validamos que OK no sea 0
		if [ ! -z $CANT_REG_OK ] && [ "$ERROR_CAMPO" = "0" ]; then
			
			#validamos el formato y la estructura del Registro.
			comando=`echo "$LINE" | grep $REGEXP_REGISTRO`
			
			if [ $? = 0 ]; then
				#Comprobamos que sean validos los valores de los campo Cliente.
				id_cliente=`echo "$LINE" | cut -d"," -f1`
				
				#buscamos si el cliente existe en el maestro
				comando=`grep  "^$id_cliente;" $climae`
				
				if [ $? != 0 ];then	
					ERROR="ERROR no se encuentra el "$id_cliente" en la Base de Datos."
					ERROR_CAMPO=$clase_servicio
				else
				    #Comprobamos que sean validos los valores de los campo Fecha de Operacion.
				    fecha_operacion=`echo "$LINE" | cut -d"," -f2`
				    retorno=`verificarFormatoFecha $fecha_operacion`
				    if [ $retorno -ne 0 ]; then
					ERROR="El formato de la fecha $fecha_operacion es invalido."
					ERROR_CAMPO=$clase_servicio
				    else
					fecha_operacion=`echo "$fecha_operacion" | sed 's|^\([0-9]*\)/\([0-9]*\)/\([0-9]*\)|\3\2\1|'`
					anio_operacion=`echo "$fecha_operacion" | sed 's|^\([0-9]\{4\}\)[0-9]*|\1|'`
					fecha_hoy=`date +%Y%m%d`
					anio_hoy=`date +%Y`

					#Verificamos que la fecha sea un dentro del corriente año y menor o igual a la fecha del dia
					if [ $fecha_operacion -gt $fecha_hoy ] || [ $anio_operacion -ne $anio_hoy ]; then
						ERROR="La fecha es posterior a la actual o erronea."
						ERROR_CAMPO=$clase_servicio
					else
						#Comprobamos que sea un producto valido con el Id Plan comercial, id Clase de servicio y Id item del producto.
						id_plan_comercial=`echo "$LINE" | cut -d"," -f3`
						id_clase_servicio=`echo "$LINE" | cut -d"," -f4`
						id_item_producto=`echo "$LINE" | cut -d"," -f6 | sed 's-\r- -g' `

						#buscamos si la terna se encuentra en el maestro de productos
						comando=`grep "^[^,]*,[^,]*,$id_plan_comercial,[^,]*,$id_clase_servicio,[^,]*,[^,]*,$id_item_producto,*" $prodmae`
			
						if [ $? != 0 ]; then
							ERROR="ERROR no se encuentra la terna $id_plan_comercial $id_clase_servicio $id_item_producto en la Base de Datos."
							ERROR_CAMPO=$clase_servicio
						fi
					
					fi
				    fi
				
				fi
			
			else
				ERROR="ERROR: Estructura y formato del registro es invalida."
				ERROR_CAMPO=$clase_servicio
			fi
		
		fi

		#Ahora validamos que la clase de servicio sea distinta a la anterior mientras que la validacion de campo haya sido exitosa
		if [ $CANT_REG_OK -eq 2 ]; then
		
			if [ "$ERROR_CAMPO" = "0" ]; then
				#Comparo que los valores del bloque sean iguales.
				id_cliente_cab=`echo "$TMP_LINE" | cut -d"," -f1`
				fecha_operacion_cab=`echo "$TMP_LINE" | cut -d"," -f2 | sed 's|^\([0-9]*\)/\([0-9]*\)/\([0-9]*\)|\3\2\1|'`
				if [ "$id_cliente_cab" = "$id_cliente" ] && [ "$fecha_operacion_cab" = "$fecha_operacion" ]; then
					grabarEnParqueInstalado

					#Reseteo los valores para el siguiente bloque
					TMP_LINE=" "
					NRO_REG=0
					CANT_REG_OK=0
					ERROR_CAMPO="0"
					NRO_REG=0
				else
					ERROR="Inconsistencia de datos del bloque de registro cabecera y detalle"
					rechazarBloque "$ERROR" "$archivo_ordenado" "$TMP_LINE" "$LINE"
					CANT_REG_OK=0
					NRO_REG=0
					ERROR_CAMPO="0"
				fi
			else
				#Grabamos en inst_rechazadas los bloques incompletos
				rechazarBloque "$ERROR" "$archivo_ordenado" "$TMP_LINE" "$LINE"
			
				#Reseteo la variable OK porque el el registro del bloque es invalido
				CANT_REG_OK=0
				NRO_REG=0
				ERROR_CAMPO="0"
			fi
		fi
		REG_LEIDOS=`expr 1 + $REG_LEIDOS `
		
	done < $ORDENADAS/"$archivo_ordenado"

	if [ "$clase_servicio" = "Y" ]; then 
	    #el ultimo registro leido era un registro CABECERA, lo rechazo porque no tenia el detalle correspondiente
	    rechazarRegistro "Registro cabecera sin detalle" "$archivo_ordenado" "$TMP_LINE"

	fi

	echo "Cantidad Registros validos archivo = $REG_VALIDOS"
	echo "Cantidad Registros invalidos archivo = $REG_INVALIDOS"
	$loguearU -i "Cantidad Registros validos archivo = $REG_VALIDOS"
	$loguearU -i "Cantidad Registros invalidos archivo = $REG_INVALIDOS"
echo "=================================================================="
    fi

done

echo "Cantidad Registros validos totales = $REG_VALIDOS_TOT"
echo "Cantidad Registros invalidos totales = $REG_INVALIDOS_TOT"
$loguearU -i "Cantidad Registros validos totales = $REG_VALIDOS_TOT"
$loguearU -i "Cantidad Registros invalidos totales = $REG_INVALIDOS_TOT"
echo "=================================================================="
echo "Registros leido en total: "$REG_LEIDOS
echo "=================================================================="
    

